home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 2010 April / PCWorld0410.iso / hity wydania / Ubuntu 9.10 PL / karmelkowy-koliberek-9.10-netbook-remix-PL.iso / casper / filesystem.squashfs / usr / lib / python2.6 / collections.py < prev    next >
Text File  |  2009-11-02  |  6KB  |  150 lines
  1. __all__ = ['deque', 'defaultdict', 'namedtuple']
  2. # For bootstrapping reasons, the collection ABCs are defined in _abcoll.py.
  3. # They should however be considered an integral part of collections.py.
  4. from _abcoll import *
  5. import _abcoll
  6. __all__ += _abcoll.__all__
  7.  
  8. from _collections import deque, defaultdict
  9. from operator import itemgetter as _itemgetter
  10. from keyword import iskeyword as _iskeyword
  11. import sys as _sys
  12.  
  13. def namedtuple(typename, field_names, verbose=False):
  14.     """Returns a new subclass of tuple with named fields.
  15.  
  16.     >>> Point = namedtuple('Point', 'x y')
  17.     >>> Point.__doc__                   # docstring for the new class
  18.     'Point(x, y)'
  19.     >>> p = Point(11, y=22)             # instantiate with positional args or keywords
  20.     >>> p[0] + p[1]                     # indexable like a plain tuple
  21.     33
  22.     >>> x, y = p                        # unpack like a regular tuple
  23.     >>> x, y
  24.     (11, 22)
  25.     >>> p.x + p.y                       # fields also accessable by name
  26.     33
  27.     >>> d = p._asdict()                 # convert to a dictionary
  28.     >>> d['x']
  29.     11
  30.     >>> Point(**d)                      # convert from a dictionary
  31.     Point(x=11, y=22)
  32.     >>> p._replace(x=100)               # _replace() is like str.replace() but targets named fields
  33.     Point(x=100, y=22)
  34.  
  35.     """
  36.  
  37.     # Parse and validate the field names.  Validation serves two purposes,
  38.     # generating informative error messages and preventing template injection attacks.
  39.     if isinstance(field_names, basestring):
  40.         field_names = field_names.replace(',', ' ').split() # names separated by whitespace and/or commas
  41.     field_names = tuple(map(str, field_names))
  42.     for name in (typename,) + field_names:
  43.         if not all(c.isalnum() or c=='_' for c in name):
  44.             raise ValueError('Type names and field names can only contain alphanumeric characters and underscores: %r' % name)
  45.         if _iskeyword(name):
  46.             raise ValueError('Type names and field names cannot be a keyword: %r' % name)
  47.         if name[0].isdigit():
  48.             raise ValueError('Type names and field names cannot start with a number: %r' % name)
  49.     seen_names = set()
  50.     for name in field_names:
  51.         if name.startswith('_'):
  52.             raise ValueError('Field names cannot start with an underscore: %r' % name)
  53.         if name in seen_names:
  54.             raise ValueError('Encountered duplicate field name: %r' % name)
  55.         seen_names.add(name)
  56.  
  57.     # Create and fill-in the class template
  58.     numfields = len(field_names)
  59.     argtxt = repr(field_names).replace("'", "")[1:-1]   # tuple repr without parens or quotes
  60.     reprtxt = ', '.join('%s=%%r' % name for name in field_names)
  61.     dicttxt = ', '.join('%r: t[%d]' % (name, pos) for pos, name in enumerate(field_names))
  62.     template = '''class %(typename)s(tuple):
  63.         '%(typename)s(%(argtxt)s)' \n
  64.         __slots__ = () \n
  65.         _fields = %(field_names)r \n
  66.         def __new__(_cls, %(argtxt)s):
  67.             return _tuple.__new__(_cls, (%(argtxt)s)) \n
  68.         @classmethod
  69.         def _make(cls, iterable, new=tuple.__new__, len=len):
  70.             'Make a new %(typename)s object from a sequence or iterable'
  71.             result = new(cls, iterable)
  72.             if len(result) != %(numfields)d:
  73.                 raise TypeError('Expected %(numfields)d arguments, got %%d' %% len(result))
  74.             return result \n
  75.         def __repr__(self):
  76.             return '%(typename)s(%(reprtxt)s)' %% self \n
  77.         def _asdict(t):
  78.             'Return a new dict which maps field names to their values'
  79.             return {%(dicttxt)s} \n
  80.         def _replace(_self, **kwds):
  81.             'Return a new %(typename)s object replacing specified fields with new values'
  82.             result = _self._make(map(kwds.pop, %(field_names)r, _self))
  83.             if kwds:
  84.                 raise ValueError('Got unexpected field names: %%r' %% kwds.keys())
  85.             return result \n
  86.         def __getnewargs__(self):
  87.             return tuple(self) \n\n''' % locals()
  88.     for i, name in enumerate(field_names):
  89.         template += '        %s = _property(_itemgetter(%d))\n' % (name, i)
  90.     if verbose:
  91.         print template
  92.  
  93.     # Execute the template string in a temporary namespace and
  94.     # support tracing utilities by setting a value for frame.f_globals['__name__']
  95.     namespace = dict(_itemgetter=_itemgetter, __name__='namedtuple_%s' % typename,
  96.                      _property=property, _tuple=tuple)
  97.     try:
  98.         exec template in namespace
  99.     except SyntaxError, e:
  100.         raise SyntaxError(e.message + ':\n' + template)
  101.     result = namespace[typename]
  102.  
  103.     # For pickling to work, the __module__ variable needs to be set to the frame
  104.     # where the named tuple is created.  Bypass this step in enviroments where
  105.     # sys._getframe is not defined (Jython for example).
  106.     if hasattr(_sys, '_getframe'):
  107.         result.__module__ = _sys._getframe(1).f_globals.get('__name__', '__main__')
  108.  
  109.     return result
  110.  
  111.  
  112.  
  113.  
  114.  
  115.  
  116. if __name__ == '__main__':
  117.     # verify that instances can be pickled
  118.     from cPickle import loads, dumps
  119.     Point = namedtuple('Point', 'x, y', True)
  120.     p = Point(x=10, y=20)
  121.     assert p == loads(dumps(p))
  122.  
  123.     # test and demonstrate ability to override methods
  124.     class Point(namedtuple('Point', 'x y')):
  125.         __slots__ = ()
  126.         @property
  127.         def hypot(self):
  128.             return (self.x ** 2 + self.y ** 2) ** 0.5
  129.         def __str__(self):
  130.             return 'Point: x=%6.3f  y=%6.3f  hypot=%6.3f' % (self.x, self.y, self.hypot)
  131.  
  132.     for p in Point(3, 4), Point(14, 5/7.):
  133.         print p
  134.  
  135.     class Point(namedtuple('Point', 'x y')):
  136.         'Point class with optimized _make() and _replace() without error-checking'
  137.         __slots__ = ()
  138.         _make = classmethod(tuple.__new__)
  139.         def _replace(self, _map=map, **kwds):
  140.             return self._make(_map(kwds.get, ('x', 'y'), self))
  141.  
  142.     print Point(11, 22)._replace(x=100)
  143.  
  144.     Point3D = namedtuple('Point3D', Point._fields + ('z',))
  145.     print Point3D.__doc__
  146.  
  147.     import doctest
  148.     TestResults = namedtuple('TestResults', 'failed attempted')
  149.     print TestResults(*doctest.testmod())
  150.